/*******************************************************************************
  * 文件：HobCtrl.h
  * 作者：djy
  * 版本：v1.0.0
  * 日期：2020-11-27
  * 说明：炉头运行控制
*******************************************************************************/
/* 头文件 *********************************************************************/
#include "HobCtrl.h"
#include "DevRun.h"
#include "DevState.h"
#include "DevStandby.h"
#include "Debug.h"
#include "Buzzer.h"
#include "Hardware_IO.h"
#include "Display.h"
#include "YLDeviceCtrl.h"
#include "RunProtect.h"

/* 宏定义 *********************************************************************/
/* 类型定义 *******************************************************************/
/* 变量定义 *******************************************************************/
extern DevRunCtrl_ts sDevRunCtrl;
/* 函数声明 *******************************************************************/
/* 函数定义 *******************************************************************/

/*******************************************************************************
  * 函数名：HobCtrl_DurationTimingHook
  * 功  能：设备运行-定时时间显示处理
  * 参  数：无
  * 返回值：无
  * 说  明：CZ在定时运行时，时间区域显示管理统一由此函数负责
*******************************************************************************/
void HobCtrl_DurationTimingHook(void)
{
    // 若设备不在运行状态，提前退出
    if(eDEV_RUN != Dev_GetCurrentState())
    {
        OS_TimerStop(&sDevRunCtrl.sTimeBlinkTimer);
        return;
    }

    // 若所有CZ均不在定时，提前退出
    if(DevRun_CheckTimingEnable() == FALSE)
    {
        // 检查是否开启童锁
        if(Dev_GetChildLock() == TRUE)
        {
            // 显示Lo
            Display_ShowLock();
        }
        else
        {
            // 显示“--”
            Display_ShowIdle();
        }

        // 信息调试
        DEBUG("All CZs exit duration\r\n");

        // 关闭定时器
        OS_TimerStop(&sDevRunCtrl.sTimeBlinkTimer);
        
        return;
    }

    // 查找处于定时中且时长最小的CZ
    U8 u8ShortestCZ = u8CZ_INVALID;
    U16 u16TimingTimeSec = u16MAX_VALUE;

    // 查找处于定时运行中 且 时长最小的CZ
    for(U8 u8CZIndex = u8CZ1;u8CZIndex <= u8CZ4;u8CZIndex++)
    {
        if(sDevRunCtrl.bTimerEnable[u8CZIndex] == TRUE 
            && sDevRunCtrl.eRunState[u8CZIndex] == eHOB_RUNNING
                && sDevRunCtrl.au16TimingTimeS[u8CZIndex] < u16TimingTimeSec)
        {
            u8ShortestCZ = u8CZIndex;
            u16TimingTimeSec = sDevRunCtrl.au16TimingTimeS[u8CZIndex];
        }
    }

    // 是否已找到运行中，且定时最短的CZ
    if(u8ShortestCZ <= u8CZ4)
    {
        // 若当前选中的炉头并非定时时间最短的，需要显示当前炉头三秒，再切换至定时最短的CZ
        if(sDevRunCtrl.u8CZIndex != u8ShortestCZ && OS_TimerGetExpiredTimes(&sDevRunCtrl.sTimeBlinkTimer) <= 6)
        {
            // 信息调试
            DEBUG("Display current CZ:%d\r\n",sDevRunCtrl.u8CZIndex+1);

            // 检查当前炉头是否开启定时
            if(sDevRunCtrl.bTimerEnable[sDevRunCtrl.u8CZIndex] == TRUE )
            {
                // 显示当前指向炉头的定时时间
                Display_ShowTime(sDevRunCtrl.au8TimingTime[sDevRunCtrl.u8CZIndex]);
                
                // 闪烁当前指向CZ的dot
                if(OS_TimerGetExpiredTimes(&sDevRunCtrl.sTimeBlinkTimer)%2)
                {
                    Display_HobDot(sDevRunCtrl.u8CZIndex,ON);
                }
                else
                {
                    Display_HobDot(sDevRunCtrl.u8CZIndex,OFF);
                }
            }
            else
            {
                // 时间显示--
                Display_ShowIdle();

                // Dot熄灭
                Display_HobDot(sDevRunCtrl.u8CZIndex,OFF);
            }
            
            // 其他开启定时的CZ Dot常亮
            for(U8 u8CZIndex = u8CZ1;u8CZIndex <= u8CZ4;u8CZIndex++)
            {
                if(sDevRunCtrl.bTimerEnable[u8CZIndex] == TRUE && u8CZIndex != sDevRunCtrl.u8CZIndex)
                {
                    Display_HobDot(u8CZIndex,ON);
                }
            }
            
            // 在第三秒时，将当前CZ指向时间最短（即需要闪烁Dot）的CZ
            if(OS_TimerGetExpiredTimes(&sDevRunCtrl.sTimeBlinkTimer) >= 6)
            {
                sDevRunCtrl.u8CZIndex = u8ShortestCZ;
            }
        }
        else 
        {
            // 信息调试
//            DEBUG("Display shortest CZ:%d\r\n",sDevRunCtrl.u8CZIndex+1);
            
            // 显示定时时间最短的
            // 若开启童锁 则 闪烁Lo和时间
            if(Dev_GetChildLock() == TRUE)
            {
                if(OS_TimerGetExpiredTimes(&sDevRunCtrl.sTimeBlinkTimer)%2)
                {
                    // 显示时间
                    Display_ShowTime(sDevRunCtrl.au8TimingTime[u8ShortestCZ]);
                }
                else
                {
                    // 显示Lo
                    Display_ShowLock();
                }
            }
            else
            {
                // 显示时间
                Display_ShowTime(sDevRunCtrl.au8TimingTime[u8ShortestCZ]);
            }
        
            // 闪烁u8ShortestCZ的Dot
            if(OS_TimerGetExpiredTimes(&sDevRunCtrl.sTimeBlinkTimer)%2)
            {
                Display_HobDot(u8ShortestCZ,ON);
            }
            else
            {
                Display_HobDot(u8ShortestCZ,OFF);
            }
        
            // 其他开定时的CZ Dot 常亮
            for(U8 u8CZIndex = u8CZ1;u8CZIndex <= u8CZ4;u8CZIndex++)
            {
                if(sDevRunCtrl.bTimerEnable[u8CZIndex] == TRUE && u8CZIndex != u8ShortestCZ)
                {
                    Display_HobDot(u8CZIndex,ON);
                }
            }
        
            // 在第三秒时，将当前CZ指向时间最短（即需要闪烁Dot）的CZ
            if(OS_TimerGetExpiredTimes(&sDevRunCtrl.sTimeBlinkTimer) >= 6)
            {
                sDevRunCtrl.u8CZIndex = u8ShortestCZ;
            }
        }
    }
    else
    {
        // 信息调试
        DEBUG("All timing CZ not running\r\n");

        // 查找处于定时中（但不运行）且时长最小的CZ
        U8 u8ShortestCZ = u8CZ_INVALID;
        U16 u16TimingTimeSec = u16MAX_VALUE;
            
        // 定时中的灶头全部不在运行，比如已移锅、已暂停等，Dot均常亮
        for(U8 u8CZIndex = u8CZ1;u8CZIndex <= u8CZ4;u8CZIndex++)
        {
            if(sDevRunCtrl.bTimerEnable[u8CZIndex] == TRUE)
            {
                // Dot均常亮
                Display_HobDot(u8CZIndex,ON);

                // 找到此时最小时间的定时炉头
                if(sDevRunCtrl.au16TimingTimeS[u8CZIndex] < u16TimingTimeSec)
                {
                    u8ShortestCZ = u8CZIndex;
                    u16TimingTimeSec = sDevRunCtrl.au16TimingTimeS[u8CZIndex];
                }
            }
        }

        // 此时若开启童锁，则显示Lo
        if(Dev_GetChildLock() == TRUE)
        {
            // 显示Lo
            Display_ShowLock();
        }
        else
        {
            // 显示最小时间
            Display_ShowTime(sDevRunCtrl.au8TimingTime[u8ShortestCZ]);
        }
    }
}


/*******************************************************************************
  * 函数名：HobCtrl_Hob1TimingHook
  * 功  能：设备运行-炉头1定时运行控制
  * 参  数：无
  * 返回值：无
  * 说  明：无
*******************************************************************************/
static void HobCtrl_Hob1TimingHook(void)
{
    if(eDEV_RUN != Dev_GetCurrentState())
    {
        OS_TimerStop(&sDevRunCtrl.asLevelBlinkTimer[u8CZ1]);
        return;
    }
    
    // 根据当前状态，执行不同操作
    if(sDevRunCtrl.eRunState[u8CZ1] == eHOB_RUNNING)
    {
        // 运行中，定时烹饪使能
        if(sDevRunCtrl.bTimerEnable[u8CZ1] == TRUE)
        {
            if(sDevRunCtrl.au16TimingTimeS[u8CZ1] > 0)
            {
                // 倒数计时
                sDevRunCtrl.au16TimingTimeS[u8CZ1]--;

                // 分钟倒计时
                if(sDevRunCtrl.au16TimingTimeS[u8CZ1]%60 == 0)
                {
                    // 更新分钟计数
                    sDevRunCtrl.au8TimingTime[u8CZ1]--;
                }
                
                // 定时时间到
                if(sDevRunCtrl.au16TimingTimeS[u8CZ1] == 0)
                {
                    // 停止加热
                    HobCtrl_StopHeating(u8CZ1);
                    return;
                }
            }
        }    

        // 检查锅具是否存在
        if(YLComm_PanStateGet(u8CZ1) == OFF)
        {
            // 锅具状态返回有延迟，需要运行一秒后再确认锅具是否存在
            if(sDevRunCtrl.u16ContinuousRunTime[u8CZ1] <= 1)
            {
                // 调试信息
                DEBUG("CZ1 run at least 1s\r\n");
                
                // 当前档位持续运行时间增加
                sDevRunCtrl.u16ContinuousRunTime[u8CZ1]++;
            }
            else
            {
                // 信息调试
                DEBUG("CZ1 pan remove,change to S2\r\n");

                // 切换至S4
                sDevRunCtrl.eRunState[u8CZ1] = eHOB_IDLE_S2;
                
                // 持续运行时间清零
                sDevRunCtrl.u16ContinuousRunTime[u8CZ1] = 0;
                
                // 复位空闲检测
                DevStandby_ResetIdleCheck();

                // 重启定时器，定时时间修改为500ms
                OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ1],500,HobCtrl_Hob1TimingHook);
            }
        }
        else
        {
            // 当前档位持续运行时间增加
            sDevRunCtrl.u16ContinuousRunTime[u8CZ1]++;
        }
    }
    else if(sDevRunCtrl.eRunState[u8CZ1] == eHOB_IDLE_S2)
    {
        // 30S内如果有锅具放置，切换至eHOB_RUNNING
        if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ1]) < 60)
        {
            // 检查锅具状态
            if(YLComm_PanStateGet(u8CZ1) == ON)
            {
                // 锅具已放置
                DEBUG("CZ1 pan on,change to Running\r\n");
                
                // 切换至Running
                sDevRunCtrl.eRunState[u8CZ1] = eHOB_RUNNING;
                
                // 显示档位
                Display_Hob1Gear(sDevRunCtrl.au8Level[u8CZ1]);
                
                // 重启定时器，定时时间修改为1S
                OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ1],1000,HobCtrl_Hob1TimingHook);
            }
            else
            {
                // 闪烁‘U’
                if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ1])%2)
                {
                    // 显示档位
                    Display_Hob1NoPot();
                }
                else
                {
                    // 清除档位显示
                    Display_Hob1Clear();
                }

                // 复位空闲检测
                DevStandby_ResetIdleCheck();
            }
        }
        else
        {
            // 超过30S未放置锅具
            DEBUG("CZ1 no pan over 30s,change to S1\r\n");
            
            // 停止加热
            HobCtrl_StopHeating(u8CZ1);
            return;
        }
    }
    else if(sDevRunCtrl.eRunState[u8CZ1] == eHOB_PAUSE)
    {
        if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ1])%2)
        {
            // 显示暂停
            Display_Hob1Pause();
        }
        else
        {
            // 清除档位显示
            Display_Hob1Clear();
        }
    }
}

/*******************************************************************************
  * 函数名：HobCtrl_Hob2TimingHook
  * 功  能：设备运行-炉头2定时运行控制
  * 参  数：无
  * 返回值：无
  * 说  明：无
*******************************************************************************/
static void HobCtrl_Hob2TimingHook(void)
{
    if(eDEV_RUN != Dev_GetCurrentState())
    {
        OS_TimerStop(&sDevRunCtrl.asLevelBlinkTimer[u8CZ2]);
        return;
    }
    
    // 根据当前状态，执行不同操作
    if(sDevRunCtrl.eRunState[u8CZ2] == eHOB_RUNNING)
    {
        // 运行中，定时烹饪使能
        if(sDevRunCtrl.bTimerEnable[u8CZ2] == TRUE)
        {
            if(sDevRunCtrl.au16TimingTimeS[u8CZ2] > 0)
            {
                // 倒数计时
                sDevRunCtrl.au16TimingTimeS[u8CZ2]--;

                // 分钟倒计时
                if(sDevRunCtrl.au16TimingTimeS[u8CZ2]%60 == 0)
                {
                    // 更新分钟计数
                    sDevRunCtrl.au8TimingTime[u8CZ2]--;
                }
                
                // 定时时间到
                if(sDevRunCtrl.au16TimingTimeS[u8CZ2] == 0)
                {
                    // 停止加热
                    HobCtrl_StopHeating(u8CZ2);
                    return;
                }
            }
        }    

        // 检查锅具是否存在
        if(YLComm_PanStateGet(u8CZ2) == OFF)
        {
            // 锅具状态返回有延迟，需要运行一秒后再确认锅具是否存在
            if(sDevRunCtrl.u16ContinuousRunTime[u8CZ2] <= 1)
            {
                // 调试信息
                DEBUG("CZ2 run at least 1s\r\n");
                
                // 当前档位持续运行时间增加
                sDevRunCtrl.u16ContinuousRunTime[u8CZ2]++;
            }
            else
            {
                // 信息调试
                DEBUG("CZ2 pan remove,change to S2\r\n");

                // 切换至S4
                sDevRunCtrl.eRunState[u8CZ2] = eHOB_IDLE_S2;
                
                // 持续运行时间清零
                sDevRunCtrl.u16ContinuousRunTime[u8CZ2] = 0;
                
                // 复位空闲检测
                DevStandby_ResetIdleCheck();

                // 重启定时器，定时时间修改为500ms
                OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ2],500,HobCtrl_Hob2TimingHook);
            }
        }
        else
        {
            // 当前档位持续运行时间增加
            sDevRunCtrl.u16ContinuousRunTime[u8CZ2]++;
        }
    }
    else if(sDevRunCtrl.eRunState[u8CZ2] == eHOB_IDLE_S2)
    {
        // 30S内如果有锅具放置，切换至eHOB_RUNNING
        if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ2]) < 60)
        {
            // 检查锅具状态
            if(YLComm_PanStateGet(u8CZ2) == ON)
            {
                // 锅具已放置
                DEBUG("CZ2 pan on,change to Running\r\n");
                
                // 切换至Running
                sDevRunCtrl.eRunState[u8CZ2] = eHOB_RUNNING;
                
                // 显示档位
                Display_Hob2Gear(sDevRunCtrl.au8Level[u8CZ2]);
                
                // 重启定时器，定时时间修改为1S
                OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ2],1000,HobCtrl_Hob2TimingHook);
            }
            else
            {
                // 闪烁‘U’
                if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ2])%2)
                {
                    // 显示档位
                    Display_Hob2NoPot();
                }
                else
                {
                    // 清除档位显示
                    Display_Hob2Clear();
                }

                // 复位空闲检测
                DevStandby_ResetIdleCheck();
            }
        }
        else
        {
            // 超过30S未放置锅具
            DEBUG("CZ2 no pan over 30s,change to S1\r\n");
            
            // 停止加热
            HobCtrl_StopHeating(u8CZ2);
            return;
        }
    }
    else if(sDevRunCtrl.eRunState[u8CZ2] == eHOB_PAUSE)
    {
        if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ2])%2)
        {
            // 显示暂停
            Display_Hob2Pause();
        }
        else
        {
            // 清除档位显示
            Display_Hob2Clear();
        }
    }
}

/*******************************************************************************
  * 函数名：HobCtrl_Hob3TimingHook
  * 功  能：设备运行-炉头3定时运行控制
  * 参  数：无
  * 返回值：无
  * 说  明：无
*******************************************************************************/
static void HobCtrl_Hob3TimingHook(void)
{
    if(eDEV_RUN != Dev_GetCurrentState())
    {
        OS_TimerStop(&sDevRunCtrl.asLevelBlinkTimer[u8CZ3]);
        return;
    }
    
    // 根据当前状态，执行不同操作
    if(sDevRunCtrl.eRunState[u8CZ3] == eHOB_RUNNING)
    {
        // 运行中，定时烹饪使能
        if(sDevRunCtrl.bTimerEnable[u8CZ3] == TRUE)
        {
            if(sDevRunCtrl.au16TimingTimeS[u8CZ3] > 0)
            {
                // 倒数计时
                sDevRunCtrl.au16TimingTimeS[u8CZ3]--;

                // 分钟倒计时
                if(sDevRunCtrl.au16TimingTimeS[u8CZ3]%60 == 0)
                {
                    // 更新分钟计数
                    sDevRunCtrl.au8TimingTime[u8CZ3]--;
                }
                
                // 定时时间到
                if(sDevRunCtrl.au16TimingTimeS[u8CZ3] == 0)
                {
                    // 停止加热
                    HobCtrl_StopHeating(u8CZ3);
                    return;
                }
            }
        }    

        // 检查锅具是否存在
        if(YLComm_PanStateGet(u8CZ3) == OFF)
        {
            // 锅具状态返回有延迟，需要运行一秒后再确认锅具是否存在
            if(sDevRunCtrl.u16ContinuousRunTime[u8CZ3] <= 1)
            {
                // 调试信息
                DEBUG("CZ3 run at least 1s\r\n");
                
                // 当前档位持续运行时间增加
                sDevRunCtrl.u16ContinuousRunTime[u8CZ3]++;
            }
            else
            {
                // 信息调试
                DEBUG("CZ3 pan remove,change to S2\r\n");

                // 切换至S4
                sDevRunCtrl.eRunState[u8CZ3] = eHOB_IDLE_S2;
                
                // 持续运行时间清零
                sDevRunCtrl.u16ContinuousRunTime[u8CZ3] = 0;
                
                // 复位空闲检测
                DevStandby_ResetIdleCheck();

                // 重启定时器，定时时间修改为500ms
                OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ3],500,HobCtrl_Hob3TimingHook);
            }
        }
        else
        {
            // 当前档位持续运行时间增加
            sDevRunCtrl.u16ContinuousRunTime[u8CZ3]++;
        }
    }
    else if(sDevRunCtrl.eRunState[u8CZ3] == eHOB_IDLE_S2)
    {
        // 30S内如果有锅具放置，切换至eHOB_RUNNING
        if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ3]) < 60)
        {
            // 检查锅具状态
            if(YLComm_PanStateGet(u8CZ3) == ON)
            {
                // 锅具已放置
                DEBUG("CZ3 pan on,change to Running\r\n");
                
                // 切换至Running
                sDevRunCtrl.eRunState[u8CZ3] = eHOB_RUNNING;
                
                // 显示档位
                Display_Hob3Gear(sDevRunCtrl.au8Level[u8CZ3]);
                
                // 重启定时器，定时时间修改为1S
                OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ3],1000,HobCtrl_Hob3TimingHook);
            }
            else
            {
                // 闪烁‘U’
                if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ3])%2)
                {
                    // 显示档位
                    Display_Hob3NoPot();
                }
                else
                {
                    // 清除档位显示
                    Display_Hob3Clear();
                }

                // 复位空闲检测
                DevStandby_ResetIdleCheck();
            }
        }
        else
        {
            // 超过30S未放置锅具
            DEBUG("CZ3 no pan over 30s,change to S1\r\n");
            
            // 停止加热
            HobCtrl_StopHeating(u8CZ3);
            return;
        }
    }
    else if(sDevRunCtrl.eRunState[u8CZ3] == eHOB_PAUSE)
    {
        if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ3])%2)
        {
            // 显示暂停
            Display_Hob3Pause();
        }
        else
        {
            // 清除档位显示
            Display_Hob3Clear();
        }
    }
}

/*******************************************************************************
  * 函数名：HobCtrl_Hob4TimingHook
  * 功  能：设备运行-炉头4定时运行控制
  * 参  数：无
  * 返回值：无
  * 说  明：无
*******************************************************************************/
static void HobCtrl_Hob4TimingHook(void)
{
    if(eDEV_RUN != Dev_GetCurrentState())
    {
        OS_TimerStop(&sDevRunCtrl.asLevelBlinkTimer[u8CZ4]);
        return;
    }
    
    // 根据当前状态，执行不同操作
    if(sDevRunCtrl.eRunState[u8CZ4] == eHOB_RUNNING)
    {
        // 运行中，定时烹饪使能
        if(sDevRunCtrl.bTimerEnable[u8CZ4] == TRUE)
        {
            if(sDevRunCtrl.au16TimingTimeS[u8CZ4] > 0)
            {
                // 倒数计时
                sDevRunCtrl.au16TimingTimeS[u8CZ4]--;

                // 分钟倒计时
                if(sDevRunCtrl.au16TimingTimeS[u8CZ4]%60 == 0)
                {
                    // 更新分钟计数
                    sDevRunCtrl.au8TimingTime[u8CZ4]--;
                }
                
                // 定时时间到
                if(sDevRunCtrl.au16TimingTimeS[u8CZ4] == 0)
                {
                    // 停止加热
                    HobCtrl_StopHeating(u8CZ4);
                    return;
                }
            }
        }    

        // 检查锅具是否存在
        if(YLComm_PanStateGet(u8CZ4) == OFF)
        {
            // 锅具状态返回有延迟，需要运行一秒后再确认锅具是否存在
            if(sDevRunCtrl.u16ContinuousRunTime[u8CZ4] <= 1)
            {
                // 调试信息
                DEBUG("CZ4 run at least 1s\r\n");
                
                // 当前档位持续运行时间增加
                sDevRunCtrl.u16ContinuousRunTime[u8CZ4]++;
            }
            else
            {
                // 信息调试
                DEBUG("CZ4 pan remove,change to S2\r\n");

                // 切换至S4
                sDevRunCtrl.eRunState[u8CZ4] = eHOB_IDLE_S2;
                
                // 持续运行时间清零
                sDevRunCtrl.u16ContinuousRunTime[u8CZ4] = 0;
                
                // 复位空闲检测
                DevStandby_ResetIdleCheck();

                // 重启定时器，定时时间修改为500ms
                OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ4],500,HobCtrl_Hob4TimingHook);
            }
        }
        else
        {
            // 当前档位持续运行时间增加
            sDevRunCtrl.u16ContinuousRunTime[u8CZ4]++;
        }
    }
    else if(sDevRunCtrl.eRunState[u8CZ4] == eHOB_IDLE_S2)
    {
        // 30S内如果有锅具放置，切换至eHOB_RUNNING
        if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ4]) < 60)
        {
            // 检查锅具状态
            if(YLComm_PanStateGet(u8CZ4) == ON)
            {
                // 锅具已放置
                DEBUG("CZ4 pan on,change to Running\r\n");
                
                // 切换至Running
                sDevRunCtrl.eRunState[u8CZ4] = eHOB_RUNNING;
                
                // 显示档位
                Display_Hob4Gear(sDevRunCtrl.au8Level[u8CZ4]);
                
                // 重启定时器，定时时间修改为1S
                OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ4],1000,HobCtrl_Hob4TimingHook);
            }
            else
            {
                // 闪烁‘U’
                if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ4])%2)
                {
                    // 显示档位
                    Display_Hob4NoPot();
                }
                else
                {
                    // 清除档位显示
                    Display_Hob4Clear();
                }

                // 复位空闲检测
                DevStandby_ResetIdleCheck();
            }
        }
        else
        {
            // 超过30S未放置锅具
            DEBUG("CZ4 no pan over 30s,change to S1\r\n");
            
            // 停止加热
            HobCtrl_StopHeating(u8CZ4);
            return;
        }
    }
    else if(sDevRunCtrl.eRunState[u8CZ4] == eHOB_PAUSE)
    {
        if(OS_TimerGetExpiredTimes(&sDevRunCtrl.asLevelBlinkTimer[u8CZ4])%2)
        {
            // 显示暂停
            Display_Hob4Pause();
        }
        else
        {
            // 清除档位显示
            Display_Hob4Clear();
        }
    }
}

/*******************************************************************************
  * 函数名：HobCtrl_GetGoalPower
  * 功  能：设备运行-获取目标功率
  * 参  数：U8 u8CZ：炉头编号 0-3
  *        U8 u8Level：档位 0-10
  * 返回值：无
  * 说  明：先在此处设置为16位无符号数据，后续需要修改为8位的
*******************************************************************************/
U8 HobCtrl_GetGoalPower(U8 u8CZ,U8 u8Level)
{
    return 0;
}

/*******************************************************************************
  * 函数名：HobCtrl_StopHeating
  * 功  能：设备运行-炉头停止运行
  * 参  数：U8 u8Hob：炉头编号 1\2\3\4
  * 返回值：无
  * 说  明：无
*******************************************************************************/
void HobCtrl_StopHeating(U8 u8CZIndex)
{
    // 信息调试
    DEBUG("CZ %d stop heating\r\n",u8CZIndex+1);

    // 切换状态：结束运行 
    sDevRunCtrl.eRunState[u8CZIndex] = eHOB_END;

    // 档位清零
    sDevRunCtrl.au8Level[u8CZIndex] = 0;

    // 定时时间清零
    sDevRunCtrl.au16TimingTimeS[u8CZIndex] = 0;
    sDevRunCtrl.au8TimingTime[u8CZIndex] = 0;
    
    // 定时标志位清零
    sDevRunCtrl.bTimerEnable[u8CZIndex] = FALSE;

    //关闭Dot显示
    Display_HobDot(u8CZIndex,OFF);
    
    // IPG功率清零
    YLComm_CookZoneCtrl(u8CZIndex,0);
    
    // 复位空闲检测
    DevStandby_ResetIdleCheck();

    // 设备开机时，需要显示档位 切换状态
    if(eDEV_RUN == Dev_GetCurrentState())
    {
        // 根据当前选中炉头，重新启动档位显示定时器
        switch(u8CZIndex)
        {
        case u8CZ1:
            // 显示档位0
            Display_Hob1Gear(sDevRunCtrl.au8Level[u8CZ1]);
            // 重启定时器
            OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ1],500,DevRun_CZ1LevelBlinkHook);
        break;
        case u8CZ2:
            // 显示档位0
            Display_Hob2Gear(sDevRunCtrl.au8Level[u8CZ2]);
            // 重启定时器
            OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ2],500,DevRun_CZ2LevelBlinkHook);
        break;
        case u8CZ3:
            // 显示档位0
            Display_Hob3Gear(sDevRunCtrl.au8Level[u8CZ3]);
            // 重启定时器
            OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ3],500,DevRun_CZ3LevelBlinkHook);
        break;
        case u8CZ4:
            // 显示档位0
            Display_Hob4Gear(sDevRunCtrl.au8Level[u8CZ4]);
            // 重启定时器
            OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ4],500,DevRun_CZ4LevelBlinkHook);
        break;
        default:
        break;
        }     
        
        // 蜂鸣器提示音
        Buzzer_Play(eBUZZER_SOUND_COOKING_END,eBUZZER_VOL_HIGH);
    }
}

/*******************************************************************************
  * 函数名：HobCtrl_PauseHeating
  * 功  能：设备运行-炉头暂停加热
  * 参  数：U8 u8Hob：炉头编号 1\2\3\4
  * 返回值：无
  * 说  明：无
*******************************************************************************/
void HobCtrl_PauseHeating(U8 u8CZIndex)
{
    // 信息调试
    DEBUG("CZ %d pause heating\r\n",u8CZIndex+1);

}

/*******************************************************************************
  * 函数名：HobCtrl_ResumeHeating
  * 功  能：设备运行-炉头恢复加热
  * 参  数：U8 u8Hob：炉头编号 1\2\3\4
  * 返回值：无
  * 说  明：无
*******************************************************************************/
void HobCtrl_ResumeHeating(U8 u8CZIndex)
{
    // 信息调试
    DEBUG("CZ %d resume heating\r\n",u8CZIndex+1);

}

/*******************************************************************************
   * 函数名：HobCtrl_StartHeating
  * 功  能：设备运行-炉头开始运行
  * 参  数：U8 u8Hob：炉头编号 1\2\3\4
  * 返回值：无
  * 说  明：无
*******************************************************************************/
void HobCtrl_StartHeating(U8 u8CZIndex)
{
    // 信息调试
    DEBUG("CZ %d start heating, lvl:%d \r\n",u8CZIndex+1,sDevRunCtrl.au8Level[u8CZIndex]);

    // 切换状态：运行中
    sDevRunCtrl.eRunState[u8CZIndex] = eHOB_RUNNING;

    // 根据当前选中炉头，启动档位显示定时器
    switch(u8CZIndex)
    {
    case u8CZ1:
        // 显示档位
        Display_Hob1Gear(sDevRunCtrl.au8Level[u8CZ1]);
        // 重启定时器
        OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ1],1000,HobCtrl_Hob1TimingHook);
    break;
    case u8CZ2:
        // 显示档位
        Display_Hob2Gear(sDevRunCtrl.au8Level[u8CZ2]);
        // 重启定时器
        OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ2],1000,HobCtrl_Hob2TimingHook);
    break;
    case u8CZ3:
        // 显示档位
        Display_Hob3Gear(sDevRunCtrl.au8Level[u8CZ3]);
        // 重启定时器
        OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ3],1000,HobCtrl_Hob3TimingHook);
    break;
    case u8CZ4:
        // 显示档位
        Display_Hob4Gear(sDevRunCtrl.au8Level[u8CZ4]);
        // 重启定时器
        OS_TimerRestart(&sDevRunCtrl.asLevelBlinkTimer[u8CZ4],1000,HobCtrl_Hob4TimingHook);
    break;
    default:
    break;
    }

    // 蜂鸣器提示音
    Buzzer_Play(eBUZZER_SOUND_START_COOKING,eBUZZER_VOL_HIGH);
}

/***************************** 文件结束 ***************************************/

